<?php
/**
 * Liste d'un BPO d'un item :
 * - ses prérequis skills
 * - ses prérequis matériaux
 * - ses prérequis etc ..
 * @author  Joseph Lemoine - lemoine.joseph@gmail.com
 * @version 3
 */
class evebpo extends Dao {

    /**
     * Caractéristiques des decryptors
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @var	array	[decryptorRace][ID][modifier] = valeur
     */
    private static $_decryptor;

    /**
     * Caractéristiques des decryptors
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @var	array	[decryptorRace][ID][modifier] = valeur
     */
    private static $_meta;

    /**
     * Caractéristiques du BPO chargé
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @var	array	(nomCarac => Valeur)
     */
    public $carac;

    /**
     * Item auquel est lié ce BPO
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @var	object
     */
    public $parent;

    /**
     * Nom de la base de donnée liée
     * @author  Joseph Lemoine - lemoine.joseph@gmail.com
     * @var     string
     */
    protected $_bdd = "EVE";

    /**
     * Nom de la table
     * @author  Joseph Lemoine - lemoine.joseph@gmail.com
     * @var     string
     */
    protected $_table = "invblueprinttypes";

    /**
     * Définie l'accès en lecture seule ou non de la table
     * @author  Joseph Lemoine - lemoine.joseph@gmail.com
     * @var	bool
     */
    protected $_readOnly = TRUE;

    /**
     * Liste des matériaux requis pour toute les catégories d'item et activité
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @var	array
     */
    private $_requiredStuff;

    /**
     * Liste des datacores requis pour inventer ce BPC
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @var	array   [id] = eveitem
     */
    public $requiredDC;

    /**
     * Nombre de runs de base du BPO / BPC
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @var	int
     */
    public $baseRun = 1;

    /**
     * Cout de l'invention d'un item (un seul)
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @var	float
     */
    public $inventionCost = 0;

    /**
     * Cout d'une tentative d'invention
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @var	float
     */
    public $inventionTryCost;

    /**
     * Chance d'inventer une BPC
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @var	float
     */
    public $inventionChance;

    /**
     * Meilleur decryptor retenue
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @var	pointeur
     */
    public $bestInvDecryptor;

    /**
     * Meilleur item pour l'invention retenue
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @var	pointeur
     */
    public $bestInvMeta;

    /**
     * Meilleur ratio pour l'invention
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @var	pointeur
     */
    public $bestInvRatio;

    /**
     * Liste des compétences requises pour chaque actions possible
     */

    /**
     * Surcharge du constructeur parent pré-paramétré
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @return	$this
     */
    public function __construct($parent = null){
	/* Enregistrement de l'objet parent */
	$this->parent = $parent;
	/* Appel du constructeur de Dao */
	parent::__construct($this->_base, $this->_table, $this->_readOnly);

	return $this->load($parent->typeID);
    }

    /**
     * Surcharge de la fonction parent load lancant automatiquement les méthodes
     * de récupération de matériaux
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @param	int	$id	ID à charger
     * @param	string	$column	Nom de la colonne à scanner
     * @return  bool
     */
    public function load($id = null, $column = "productTypeID", $order = null, $forceReload = false) {
	if(parent::load($id, $column, $order, $forceReload)){
	    /* Chargement du ME / PE de référence depuis l'id de CE BPO */
	    $this->carac = new IcuBPOCarac($this->blueprintTypeID);

	    if(!$this->carac->exist()){
			/* si on peu l'inventer et qu'on à pas le BPO
			 * , on le considère comme BPC ME -4 */
			if(EveMath::canBeInvented($this)){
				$this->carac->me = -4;
				$this->carac->pe = -4;

				/* Définition du nombre de runs */
				$this->baseRun = EveMath::getRuns($this->parent->groupID);

				/* Récupération des informations de l'invention T1 : */
				$sql = "SELECT t.typeID,
				t.typeName,
				t.marketGroupID,
				r.quantity,
				r.damagePerJob,
				r.activityID,
				t.groupID,
				g.categoryID
				FROM ramTypeRequirements AS r
				INNER JOIN invTypes AS t
					ON r.requiredTypeID = t.typeID
				INNER JOIN invGroups AS g
					ON t.groupID = g.groupID
				WHERE r.activityID = 8
				AND r.typeID = (
					SELECT b.blueprintTypeID
					FROM invblueprinttypes as b
					WHERE b.productTypeID = (
					SELECT i.parentTypeID
					FROM invmetatypes AS i
					WHERE i.typeID = " . $this->productTypeID . "
					))";

				/* Chargement des données relatives à l'invention */
				$this->loadRaw(Sql::run($sql, $this->_bdd));

			}
	    }

	    /* Chargement des besoins en composants */
	    if(!empty($this->blueprintTypeID))
			return $this->loadMaterial();
	}

	return FALSE;
    }

    /**
     * Listing des matériaux requis puis affichage
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @return string
     */
    public function loadMaterial(){
	/* Sélection de la méthode de récupération des matériaux */
	switch($this->techLevel){
	    case 2:
			/* Méthode spécifique au T2 */
			$this->loadmaterialT2();
			break;
	    default:
			/* Méthode générale */
			$this->loadmaterialT1();
			break;
	}

	if(!empty($this->_requiredStuff)){
	    /* Récupération du meilleur ME */
	    $this->bestME = EveMath::findBestME($this);

	    return TRUE;
	}else
	    /* On renvoit faux si aucun composant n'est trouvé */
	    return FALSE;
    }

    /**
     * Chargement des objets requis à la production de l'item lié au BPO.
     * Les matériaux suplémentaire ne sont pas soumis au wastage factor
     * Cela s'explique par le fait que reprocess une bomb ne donne que
     * les minéraux de la requète au dessus, et RIEN d'autre.
     * C'est un nerf de la compression en fait...
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @param	VOID
     * @return	VOID
     * @access	Private
     */
    private function loadmaterialT1(){
		/* Requète de récupération des matériaux T1 */
		$sql = "SELECT t.typeID, t.typeName, t.marketGroupID, m.quantity, g.groupID, g.categoryID
			FROM invTypeMaterials AS m
			INNER JOIN invTypes AS t ON m.materialTypeID = t.typeID
			INNER JOIN invgroups AS g ON g.groupID = t.groupID
			WHERE m.typeID = " . $this->productTypeID;

		$this->loadRaw(Sql::run($sql, $this->_bdd));

		/* Récupération des matériaux suplémentaires */
		$this->loadExtraMaterial();
    }

    /**
     * Récupération des composants requis pour la fabrication du T2 !
     * Il faut dans un premier temps connaitre les minéraux issus du reprocess de l'item
     * puis soustraire les minéraux issu du reprocess de la version T1 pour connaitre
     * la quantité de minéraux nécessaire. Les compos suplémentaire sont à récupérer dans
     * la table ramtyperequirements.
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @param	VOID
     * @return	VOID
     * @access	Private
     */
    private function loadmaterialT2(){
		/* Récupération des minéraux issus du reprocess du T2 : */
		$sql = "SELECT
			t.typeID,
			t.typeName,
			t.marketGroupID,
			m.quantity,
			g.groupID,
			g.categoryID
			FROM invTypeMaterials AS m
			INNER JOIN invTypes AS t ON m.materialTypeID = t.typeID
			INNER JOIN invgroups AS g ON g.groupID = t.groupID
			WHERE m.typeID = " . $this->productTypeID . ";";

		/* Exécution et tri */
		foreach(Sql::run($sql, $this->_bdd) AS $row => $detail){
			$need[$detail["marketGroupID"]][$detail["typeName"]]["qtt"] += $detail["quantity"];
			$need[$detail["marketGroupID"]][$detail["typeName"]]["id"] = $detail["typeID"];
			$need[$detail["marketGroupID"]][$detail["typeName"]]["grp"] = $detail["groupID"];
			$need[$detail["marketGroupID"]][$detail["typeName"]]["cat"] = $detail["categoryID"];
		}

		/* Récupération des minéraux issus du reprocess du T1 : */
		$sql = "SELECT
			t.typeID,
			t.typeName,
			t.marketGroupID,
			m.quantity,
			g.groupID,
			g.categoryID
			FROM invTypeMaterials AS m
			INNER JOIN invTypes AS t ON m.materialTypeID = t.typeID
			INNER JOIN invgroups AS g ON g.groupID = t.groupID
			WHERE m.typeID = (
			SELECT i.parentTypeID
			FROM invmetatypes AS i
			WHERE i.typeID = " . $this->productTypeID . "
			)";

		/* Exécution et tri */
		foreach(Sql::run($sql, $this->_bdd) AS $row => $detail){
			$need[$detail["marketGroupID"]][$detail["typeName"]]["qtt"] -= $detail["quantity"];
			$need[$detail["marketGroupID"]][$detail["typeName"]]["id"] = $detail["typeID"];
			$need[$detail["marketGroupID"]][$detail["typeName"]]["grp"] = $detail["groupID"];
			$need[$detail["marketGroupID"]][$detail["typeName"]]["cat"] = $detail["categoryID"];

			/* On vire les entrées vide */
			if($need[$detail["marketGroupID"]][$detail["typeName"]]["qtt"] <= 0)
			unset($need[$detail["marketGroupID"]][$detail["typeName"]]);
		}

		/* Chargement des dépendances */
		$row = 0;
		foreach($need AS $marketGroup => $list){
			foreach($list AS $typeName => $show){
			$listToLoad[$row]["quantity"] = $show["qtt"];
			$listToLoad[$row]["typeName"] = $typeName;
			$listToLoad[$row]["typeID"] = $show["id"];
			$listToLoad[$row]["marketGroupID"] = $marketGroup;
			$listToLoad[$row]["groupID"] = $show["grp"];

			$row++;
			}
		}

		/* Chargement des composants */
		$this->loadRaw($listToLoad);

		/* Chargements des composants suplémentaires */
		$this->loadExtraMaterial();
    }

    /**
     * Crée et analyse les composant non minéraux de base requis
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @param	array	$data	(row => details)
     * @return	VOID
     * @access	Private
     */
    private function loadRaw($data){
		foreach($data AS $row => $detail){
			/* On sauvegarde tout pour les traitements invention / copie / recherche etc ... */
			$activity = empty($detail["activityID"]) ? 1 : $detail["activityID"];
			$dmg = $activity != 1 ? $detail["damagePerJob"] : 1;

			$this->_requiredStuff[$activity][$detail["typeName"]]["qtt"] = $detail["quantity"];
			$this->_requiredStuff[$activity][$detail["typeName"]]["id"] = $detail["typeID"];
			$this->_requiredStuff[$activity][$detail["typeName"]]["market"] = $detail["marketGroupID"];
			$this->_requiredStuff[$activity][$detail["typeName"]]["group"] = $detail["groupID"];
			$this->_requiredStuff[$activity][$detail["typeName"]]["cat"] = $detail["categoryID"];
			$this->_requiredStuff[$activity][$detail["typeName"]]["dmg"] = $dmg;
		}
    }

    /**
     * Fonction de récupération des composants suplémentaires
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @param	VOID
     * @return	bool	True si succès
     * @access	Private
     */
    private function loadExtraMaterial(){
		/* Requète suplémentaire pour les items comme les bombs */
		$sql = "SELECT t.typeID,
			t.typeName,
			t.marketGroupID,
			r.quantity,
			r.damagePerJob,
			r.activityID,
			t.groupID,
			g.categoryID
			FROM ramTypeRequirements AS r
			INNER JOIN invTypes AS t
				ON r.requiredTypeID = t.typeID
			INNER JOIN invGroups AS g
				ON t.groupID = g.groupID
			WHERE r.typeID = " . $this->blueprintTypeID . "
			AND r.activityID != 8 -- Invention";

		/**
		 * NOTE :
		 * On ne récupère pas les informations concernant l'invention ici
		 * car sinon on les obtiendrait à partir du BPO T1 et non depuis
		 * l'appel du BPO T2.
		 * On récupère donc les informations d'invention que si on ne
		 * possède pas le BPO T2.
		 * Elle sont donc récupéré dans load() après le test du type de BPO
		 */

		return $this->loadRaw(Sql::run($sql, $this->_bdd));
    }

    /**
     * Retourne à eveitem un tableau avec la liste des composants requis et leur quantité
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @param	int	$activity   ID de l'activité demandé
     * @param	bool	$skill	    Renvoit également les skills requises
     * @param	bool	$testOnly   Renvoit simplement si il existe des composants dans cette activityID
     * @return	array
     */
    public function requiredComp($activity = 1, $skill = false, $testOnly = false) {
		/* parcourt des items requis pour l'activté demandé */
		if(!empty($this->_requiredStuff[$activity])){
			/* Si on veut juste vérifier la présence de composants */
			if($testOnly)
				return TRUE;
				/* Sinon si on souhaite lister les composants */
			else{
				foreach($this->_requiredStuff[$activity] AS $typeName => $detail){
					/* Renvoit avec interface */
					if($detail["cat"] != 16 || ($skill && $detail["cat"] == 16)){
						/* On renvoit un pointeur vers la quantité */
						$send[$detail["id"]] = &$this->_requiredStuff[$activity][$typeName]["qtt"];
					}
				}
			}
		}else
			/* Sinon on renvoit un tableau vide */
			$send = FALSE;

		return $send;
    }

    /**
     * Choisi les paramètres de l'invention la plus rentable
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @param	VOID
     * @return	string
     * @access	public
     */
    public function selectInventionMethod() {
		/* Détermine les chances de base de l'invention */
		$baseChance = $this->inventionBaseChance();

		/* Récupération des decryptors */
		if(empty(self::$_decryptor)){
			$this->loadDecryptor();
		}

		/* Récupération des meta possible de cet item, maximum meta 4 */
		if(empty(self::$_meta)){
			$this->loadMeta();
		}

		/* Récupération des datacores à utliser */
		if($this->requiredComp(8, 0, 1)){
			/* Récupération des composant requis pour l'invention */
			$listItem = $this->requiredComp(8);

			/* Chargement des item requis pour produire cet item */
			foreach($listItem AS $typeID => $qtt){
				$this->requiredDC[$typeID] = new eveitem($typeID, 1, $qtt);
				$invTryPrice += $this->requiredDC[$typeID]->price->buy * $qtt;
			}
		}

		$chance = EveMath::inventionChance($baseChance);

		/* Base de calcul du meilleur ratio invention + prod, sans datacore */
		$this->bestInvRatio = $this->parent->recursivePrice() + ($invTryPrice / $chance) / $this->baseRun;
		$this->bestInvDecryptor = NULL;
		$this->bestInvMeta = NULL;

		$this->sortInventionMethod(NULL, 0, $baseChance, $invTryPrice);

		/* Test des chances d'invention pour chaque decryptor si on peut */
		if(!empty(self::$_decryptor[$this->parent->raceID])) {
			foreach(self::$_decryptor[$this->parent->raceID] AS $typeID => $decryptor) {
				/* Si des item meta 1-4 existent */
				if(!empty(self::$_meta)){
					/* On test pour chaque meta possible */
					foreach(self::$_meta AS $metaLevel => $metaItem){
						$this->sortInventionMethod($decryptor, $metaItem, $baseChance, $invTryPrice);
					}
					/* Sinon on test que pour les decryptors */
				}else{
					$this->sortInventionMethod($decryptor, NULL, $baseChance, $invTryPrice);
				}
			}
		}

		/* On test aussi sans décryptor, juste avec les meta item */
		if(!empty(self::$_meta)){
			/* On test pour quache decryptor */
			foreach(self::$_meta AS $metaLevel => $metaItem){
			$this->sortInventionMethod(NULL, $metaItem, $baseChance, $invTryPrice);
			}
		}

		/* Enregistrement du résultat */
		$invMultiplier = empty($this->bestInvDecryptor) ? 1 : $this->bestInvDecryptor["inventionPropabilityMultiplier"];
		$this->inventionChance = EveMath::inventionChance($baseChance, $this->bestInvMeta["metaLevel"], $invMultiplier);
		$totalInvCost = $this->bestInvDecryptor["price"] + $this->bestInvMeta["price"] + $invTryPrice;
		$this->baseRun += $this->bestInvDecryptor["inventionMaxRunModifier"];

		/* Modification du ME et PE appliqué du fait des choix précédents */
		$this->carac->me += $this->bestInvDecryptor["inventionMEModifier"];
		$this->carac->pe += $this->bestInvDecryptor["inventionPEModifier"];

		/* Ajout du prix de l'invention pour l'affichage des compos */
		$this->inventionTryCost = $totalInvCost;
		$this->inventionCost = ((($totalInvCost / $chance) / $this->baseRun ) / $this->parent->portionSize);

		return TRUE;
    }

    /**
     * test et tri les résultat d'invention par decryptor et meta level
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @param
     * @return	VOID
     * @access	private
     */
    private function sortInventionMethod($decryptor, $metaItem, $baseChance, $invTryPrice) {
		/* Modification du ME du BPC pour les calculs */
		$this->carac->me = -4 + $decryptor["inventionMEModifier"];
		$this->carac->pe = -4 + $decryptor["inventionPEModifier"];

		/* Préparation des variables */
		$InventionMultiplier = empty($decryptor) ? 1 : $decryptor["inventionPropabilityMultiplier"];
		$chance = EveMath::inventionChance($baseChance, $metaItem["metaLevel"], $InventionMultiplier);
		$tryCost = $invTryPrice + $metaItem["price"] + $decryptor["price"];
		$nbRuns = $this->baseRun + $decryptor["inventionMaxRunModifier"];
		$runCost = $this->parent->recursivePrice() / $this->parent->qttRequired;

		$ratio = $runCost + ($tryCost / $chance) / $nbRuns;

		/* Sélection du meilleur Datacore */
		if($ratio < $this->bestInvRatio){
			$this->bestInvDecryptor = &self::$_decryptor[$this->parent->raceID][$decryptor["typeID"]];
			$this->bestInvMeta = &self::$_meta[$metaItem["metaLevel"]];
			$this->bestInvRatio = $ratio;
		}

		$this->carac->me = -4;
		$this->carac->pe = -4;
    }

    /**
     * Méthode de chargement des données des decryptors
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @param	VOID
     * @return	bool
     */
    private function loadDecryptor() {
		/* Récupération des attributs */
		$sql = "SELECT
			d.attributeID,
			a.attributeName,
			d.valueFloat,
			t.groupID,
			t.typeID,
			t.typeName
			FROM invcategories as c
			LEFT JOIN invgroups as g ON g.categoryID = c.categoryID
			LEFT JOIN invtypes AS t ON t.groupID = g.groupID
			LEFT JOIN dgmtypeattributes AS d ON d.typeID = t.typeID
			LEFT JOIN dgmattributetypes AS a ON a.attributeID = d.attributeID
			WHERE c.categoryID = 35";

		/* Tri des données */
		foreach(Sql::run($sql, $this->_bdd) AS $row => $data){

			/* Enregistrement de la race du decryptor */
			switch($data["groupID"]){
			case 728:
				$race = 4;
				break;
			case 729:
				$race = 2;
				break;
			case 730:
				$race = 8;
				break;
			case 731:
				$race = 1;
				break;
			default:
				$race = 16;
				break;
			}

			/* Enregistrement des données */
			self::$_decryptor[$race][$data["typeID"]]["name"] = $data["typeName"];
			self::$_decryptor[$race][$data["typeID"]]["typeID"] = $data["typeID"];
			self::$_decryptor[$race][$data["typeID"]][$data["attributeName"]] = $data["valueFloat"];
		}

		/* Attribution des prix */
		$priceList = array();
		foreach(self::$_decryptor AS $race => $listID)
			foreach($listID AS $typeID => $prop)
				array_push($priceList, $typeID);

		$loadPrice = EveMath::getPrice($priceList);

		foreach(self::$_decryptor AS $race => $listID)
			foreach($listID AS $typeID => $prop)
				self::$_decryptor[$race][$typeID]["price"] = $loadPrice[$typeID]->buy;

		return TRUE;
    }

    /**
     * Méthode de chargement des données des item meta 1 à 4
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @param	VOID
     * @return	bool
     */
    private function loadMeta() {
		$sql = "SELECT
			t.typeID,
			t.typeName,
			d.valueInt AS metaLevel
			FROM invmetatypes AS m
			LEFT JOIN invtypes AS t
				ON t.typeID = m.typeID
			LEFT JOIN dgmtypeattributes AS d
				ON d.typeID = m.typeID
			WHERE metaGroupID = 1
			AND d.attributeID = 633
			AND m.parentTypeID = (
				SELECT i.parentTypeID
				FROM invmetatypes AS i
				WHERE i.typeID = " . $this->productTypeID . "
				)";

		foreach(Sql::run($sql, $this->_bdd) AS $row => $data){
			self::$_meta[$data["metaLevel"]]["typeName"] = $data["typeName"];
			self::$_meta[$data["metaLevel"]]["typeID"] = $data["typeID"];
			self::$_meta[$data["metaLevel"]]["metaLevel"] = $data["metaLevel"];
		}

		/* Attribution des prix */
		if(!empty(self::$_meta)){
			/* Création de la liste des ID des prix à charger */
			$priceList = array();
			foreach(self::$_meta AS $metaLevel => $att)
			array_push($priceList, $att["typeID"]);

			/* Chargement de la liste via l'agregator */
			$loadPrice = EveMath::getPrice($priceList);

			/* Enregistrement dans cet objet */
			foreach(self::$_meta AS $metaLevel => $att)
			self::$_meta[$metaLevel]["price"] = $loadPrice[$att["typeID"]]->buy;
		}

		return TRUE;
    }

    /**
     * Récupère les chances d'inventions de base de l'item
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @param	VOID
     * @return	Float
     * @access	private
     */
    private function inventionBaseChance() {
		/**
		 * Base chance is 20% for battlecruisers, battleships, Hulk
		 ** Base chance is 25% for cruisers, industrials, Mackinaw
		 *** Base chance is 30% for frigates, destroyers, Skiff, freighters
		 **** Base chance is 40% for all other inventables
		 */

		/* Récupération de la class de l'objet
		 * categoryID = 6 // Ship
		 * groupID = 25 // Frégate
		 * groupID = 420 // Destroyer
		 * groupID = 26 // Croiseur
		 * groupID = 419 // Battlecruiser
		 * groupID = 27 // Battleship
		 * groupID = 28 // Industriel
		 * groupID = 513 // Freighter
		 * typeID = 22544 // Hulk
		 * typeID = 22548 // Mackinaw
		 * typeID = 22546 // Skiff
		 */

		/* Si on à affaire à une barge T2 */
		switch($this->productTypeID){
			/* Si c'est un hulk */
			case 22544:
			return 0.2;
			break;
			/* Si c'est un Mackinaw */
			case 22548:
			return 0.25;
			break;
			/* Si c'est un Skiff */
			case 22546:
			return 0.3;
			break;
			default:
			/* Si rien de tout ça alors on recherche son groupe */
			$sql = "SELECT
				g.groupID,
				g.categoryID
				FROM invTypes AS t
				INNER JOIN invGroups AS g ON t.groupID = g.groupID
				WHERE typeID = (
				SELECT
					i.parentTypeID
				FROM invmetatypes AS i
				WHERE i.typeID = " . $this->productTypeID . ")";
			$group = Sql::run($sql, $this->_bdd);

			/* Si ce n'est pas un ship, on renvoit 0.4 */
			if($group[0]["categoryID"] != 6){
				return 0.4;
			}else{
				/* Sinon on regarde le type de ship */
				switch($group[0]["groupID"]){
				/* Frégate */
				case 25:
					return 0.3;
					break;
				/* Croiseurs */
				case 26:
					return 0.25;
					break;
				/* Battleship */
				case 27:
					return 0.2;
					break;
				/* Indus */
				case 28:
					return 0.25;
					break;
				/* Battlecruiser */
				case 419:
					return 0.2;
					break;
				/* Destroyer */
				case 420:
					return 0.3;
					break;
				/* Freighter */
				case 513:
					return 0.3;
					break;
				/* Si ça n'est rien de tout ça */
				default:
					return 0.4;
					break;
				}
			}
			break;
		}
    }

    /**
     * Renvoit l'ID de l'interface à utiliser
     * @author	Joseph Lemoine - lemoine.joseph@gmail.com
     * @param	VOID
     * @return	int
     * @access	public
     */
    public function getInterfaceID() {
		/* Si cet item peut être inventer ET possède bien les données recherchés */
		if(EveMath::canBeInvented($this) && $this->requiredComp(8, 0, 1)){
			foreach($this->_requiredStuff[8] AS $typeName => $detail){
				/* Si ce n'est pas une skill, ou qu'on à demandé les skills */
				if($detail["cat"] != 16 && $detail["group"] == 716){
					/* On renvoit l'ID*/
					return $detail["id"];
				}
			}
		}

		/* Si rien de tout ça, on renvoit une erreur */
		return FALSE;
    }
}
?>